import asyncio
import time
from concurrent.futures import ThreadPoolExecutor


# 假设这是你的同步搜索函数（模拟）
def __search_emb_sync(delay):
    time.sleep(delay)  # 模拟耗时操作
    return f"搜索结果（耗时{delay}秒）"


# 异步包装器
async def search_emb_async(delay, executor):
    loop = asyncio.get_event_loop()
    future = loop.run_in_executor(executor, __search_emb_sync, delay)
    return await future


# 同步测试函数
def search_emb_sync(delay):
    return __search_emb_sync(delay)


# 并发测试
async def async_concurrency(num_tasks, delay, executor):
    start_time = time.time()
    tasks = [search_emb_async(delay, executor) for _ in range(num_tasks)]
    results = await asyncio.gather(*tasks)
    end_time = time.time()
    return results, end_time - start_time


# 同步测试函数
def sync_concurrency(num_tasks, delay):
    start_time = time.time()
    # results = [search_emb_sync(delay) for _ in range(num_tasks)]
    # 注意：这里我们不会真正并发执行，只是模拟顺序执行
    # 为了公平比较，我们可以使用ThreadPoolExecutor来模拟同步的并发
    with ThreadPoolExecutor(max_workers=5) as executor:
        futures = [executor.submit(search_emb_sync, delay) for _ in range(num_tasks)]
        results = [future.result() for future in futures]
    end_time = time.time()
    return results, end_time - start_time


# 主测试函数
async def main():
    num_tasks = 10  # 并发任务数
    delay = 3  # 每个任务的模拟耗时
    executor = ThreadPoolExecutor(max_workers=5)  # 线程池大小

    # 测试异步版本
    # ThreadPoolExecutor中的线程数是有限的（在这个例子中是5个），并且每个任务都需要3秒来完成，因此整个异步测试的总耗时将受到最长任务链的限制。在最坏的情况下（即所有任务几乎同时开始），你将需要等待最长的任务完成，即3秒 * (10 / 5) = 6秒
    async_results, async_duration = await async_concurrency(num_tasks, delay, executor)
    print(f"异步测试完成，耗时：{async_duration:.2f}秒")

    # 测试同步版本（使用线程池模拟并发）
    sync_results, sync_duration = sync_concurrency(num_tasks, delay)
    print(f"同步测试完成（使用线程池模拟并发），耗时：{sync_duration:.2f}秒")


# 运行事件循环
asyncio.run(main())
"""
运行结果：
异步测试完成，耗时：6.00秒
同步测试完成（使用线程池模拟并发），耗时：6.00秒

"""